/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package DAO;

import Negocio.Aluno;
import Negocio.AlunoErro;
import Negocio.Conta;
import java.io.Serializable;
import java.util.*;

/**
 *
 * @author Jeferson
 */
public class Data implements Serializable {

    private ArrayList<Aluno> alunos = new ArrayList<Aluno>();
    private HashMap<Integer, Aluno> alunorg = new HashMap<Integer, Aluno>();
    private HashMap<Long, Aluno> alunocpf = new HashMap<Long, Aluno>();
    private HashMap<Integer, Aluno> alunosFicha = new HashMap<Integer, Aluno>();
    private HashMap<String, ArrayList<Aluno>> alunosnm = new HashMap<String, ArrayList<Aluno>>();
    private HashMap<Integer, ArrayList<Aluno>> alunosPasta = new HashMap<Integer, ArrayList<Aluno>>();
    private static final long serialVersionUID = 5084805814026748847L;

    public Data() {
    }

    public void atualizaDados() {
        /*
         * HashMap<Integer, Aluno> aFicha = new HashMap<Integer, Aluno>();
         * HashMap<Integer, Aluno> arg1 = new HashMap<Integer, Aluno>();
         * HashMap<Long, Aluno> acpf = new HashMap<Long, Aluno>();
         * HashMap<String, ArrayList<Aluno>> anm = new HashMap<String,
         * ArrayList<Aluno>>(); HashMap<Integer, ArrayList<Aluno>> apst = new
         * HashMap<Integer, ArrayList<Aluno>>(); for(Aluno a : alunos){
         * aFicha.put(a.getFicha(), a); if(a.getRg()!=null) arg1.put(a.getRg(),
         * a); if(a.getCpf()!=null) acpf.put(a.getCpf(), a); ArrayList<Aluno>
         * alnsn = getAlunoNome(a.getNome()); alnsn.add(a); sort(alnsn);
         * anm.put(a.getNome(), alnsn); ArrayList<Aluno> alnsp =
         * getAlunoPasta(a.getPsti()); alnsp.add(a); sort(alnsp);
         * apst.put(a.getPsti(), alnsp); } alunosFicha = aFicha; alunorg = arg1;
         * alunocpf = acpf; alunosnm = anm; alunosPasta = apst;
         */
    }

    public void addAluno(Aluno aluno) {
        alunos.add(aluno);
        sort(alunos);
        alunosFicha.put(aluno.getFicha(), aluno);
        if(aluno.getRg()!=null)
            alunorg.put(aluno.getRg(), aluno);
        if(aluno.getCpf()!=null)
            alunocpf.put(aluno.getCpf(), aluno);
        ArrayList<Aluno> auxn = getAlunoNome(aluno.getNome());
        auxn.add(aluno);
        ArrayList<Aluno> auxp = getAlunoPasta(aluno.getPsti());
        auxp.add(aluno);
    }

    public AlunoErro validaAluno(Aluno aluno) {        
        //Verifica se existe algum aluno com a ficha cadastrada
        if (alunosFicha.containsKey(aluno.getFicha())) {
            return new AlunoErro(alunosFicha.get(aluno.getFicha()), "Ficha já Cadastrada!");
        }
        
        //Verifica se o nome não é nulo
        if(aluno.getNome()==null || aluno.getNome().equals(""))
            return new AlunoErro(null, "Nome Vazio!");

        //Verifica se existe aluno com o mesmo nome e data de nascimento cadastrado
        if (alunosnm.containsKey(aluno.getNome())) {
            ArrayList<Aluno> alns = alunosnm.get(aluno.getNome());
            for (Aluno a : alns) {
                if (aluno.nscmToString().equals(a.nscmToString())) {
                    return new AlunoErro(a, "Aluno Existente!");
                }
            }
        }

        //Verifica se existe algum aluno com o mesmo RG cadastrado
        if (aluno.getRg() != null && alunorg.containsKey(aluno.getRg())) {
            return new AlunoErro(alunorg.get(aluno.getRg()), "RG já Cadastrado");
        }

        //Verifica se existe algum aluno com o mesmo CPF cadastrado
        if (aluno.getCpf() != null && alunocpf.containsKey(aluno.getCpf())) {
            return new AlunoErro(alunocpf.get(aluno.getCpf()), "CPF já Cadastrado");
        }

        return new AlunoErro(aluno, "Aluno Adicionado!");
    }

    public boolean contem(Aluno aluno) {
        return this.alunosFicha.containsKey(aluno.getFicha());
    }

    public ArrayList<String> getArrayPastas() {
        ArrayList<String> result = new ArrayList<String>();
        ArrayList<Integer> pst = new ArrayList<Integer>();
        Set keys = alunosPasta.keySet();
        for (Object i : keys) {
            pst.add((Integer) i);
        }
        Collections.sort(pst, new Comparator() {

            @Override
            public int compare(Object acc1, Object acc2) {
                return ((Integer) acc1).compareTo(((Integer) acc2));
            }
        });
        for (int i : pst) {
            result.add("" + i + "-" + (i + 49));
        }
        return result;
    }

    public int existeAluno(Aluno aluno) {
        ArrayList<Aluno> alns = getAlunoNome(aluno.getNome());
        //System.out.println(""+alns.size());
        GregorianCalendar d1 = new GregorianCalendar();
        d1.setTimeInMillis(aluno.getNscm());
        for (Aluno a : alns) {
            GregorianCalendar d2 = new GregorianCalendar();
            d2.setTimeInMillis(a.getNscm());
            //System.out.println("a: "+a.getNome()+" "+d2.toString()+"| a2: "+aluno.getNome()+" "+d1.toString());
            System.out.println("a1: " + a.nscmToString() + " a2: " + aluno.nscmToString());
            if (d1.get(Calendar.YEAR) == d2.get(Calendar.YEAR) && d1.get(Calendar.MONTH) == d2.get(Calendar.MONTH) && d1.get(Calendar.DATE) == d2.get(Calendar.DATE)) {
                //System.out.println("a: "+a.getNome()+" "+a.getNscm()+"| a2: "+aluno.getNome()+" "+aluno.getNscm());
                return a.getFicha();
            }
        }
        return 0;
    }

    public void remAluno(Aluno a) {
        Aluno aluno = alunosFicha.get(a.getFicha());
        alunos.remove(aluno);
        sort(alunos);
        if (aluno.getRg() != null) {
            alunorg.remove(aluno.getRg());
        }
        if (aluno.getCpf() != null) {
            alunocpf.remove(aluno.getCpf());
        }
        alunosFicha.remove(aluno.getFicha());
        ArrayList<Aluno> auxn = getAlunoNome(aluno.getNome());
        auxn.remove(aluno);
        ArrayList<Aluno> auxp = getAlunoPasta(aluno.getPsti());
        auxp.remove(aluno);
    }

    public void altAluno(Aluno a1, Aluno a2) {
        remAluno(a1);
        addAluno(a2);
        /*
         * a1.setNome(a2.getNome()); a1.setresp(a2.getResp());
         * a1.setNscm(a2.getNscm()); try { a1.setRg(a2.getRg());
         * a1.setCpf(a2.getCpf()); } catch (NullPointerException ex) {
        }
         */
    }

    public ArrayList<Aluno> getAlunoNome(String nome) {
        ArrayList<Aluno> result = alunosnm.get(nome);
        if (result == null) {
            result = new ArrayList<Aluno>();
            alunosnm.put(nome, result);
        }
        sort(result);
        return result;
    }

    public ArrayList<Aluno> getAlunoPasta(int pasta) {
        ArrayList<Aluno> result = alunosPasta.get(pasta);
        if (result == null) {
            result = new ArrayList<Aluno>();
            alunosPasta.put(pasta, result);
        }
        sort(result);
        return result;
    }

    public Aluno getAlunoFicha(int ficha) {
        return alunosFicha.get(ficha);
    }

    public long getSize() {
        return alunosFicha.size();
    }

    public HashMap<Integer, Aluno> getAlunos() {
        return this.alunosFicha;
    }

    public ArrayList<Aluno> getArrayAlunos() {
        return this.alunos;
    }

    public Aluno getAlunoRg(int rg) {
        return this.alunorg.get(rg);
    }

    public Aluno getAlunoCpf(long cpf) {
        return this.alunocpf.get(cpf);
    }

    private void sort(ArrayList lista) {
        Collections.sort(lista, new Comparator() {

            @Override
            public int compare(Object acc1, Object acc2) {
                return ((Aluno) acc1).getNome().compareTo(((Aluno) acc2).getNome());
            }
        });
    }

    private HashMap<Integer, ArrayList<Aluno>> getPastas() {
        return this.alunosPasta;
    }
    
    public ArrayList<Integer> getPastasIDS(){
        ArrayList<Integer> result = new ArrayList<Integer>();
        Set<Integer> key = alunosPasta.keySet();
        for(Integer i : key)
            result.add(i);
        Collections.sort(result, new Comparator() {

            @Override
            public int compare(Object acc1, Object acc2) {
                return ((Integer) acc1).compareTo((Integer) acc2);
            }
        });
        return result;
    }
    
    public String getPastaTitle(int pasta){
        return "" + pasta + "-" + (pasta + 49);
    }

    public void remAlunos() {
        this.alunos.clear();
        this.alunocpf.clear();
        this.alunorg.clear();
        this.alunosFicha.clear();
        this.alunosPasta.clear();
        this.alunosnm.clear();
    }

    public void addAlunos(ArrayList<Aluno> alunos) {
        for (Aluno a : alunos) {
            this.alunos.add(a);
            alunosFicha.put(a.getFicha(), a);
            if (a.getRg() != null) {
                alunorg.put(a.getRg(), a);
            }
            if (a.getCpf() != null) {
                alunocpf.put(a.getCpf(), a);
            }
            ArrayList<Aluno> auxn = getAlunoNome(a.getNome());
            auxn.add(a);
            ArrayList<Aluno> auxp = getAlunoPasta(a.getPsti());
            auxp.add(a);
        }
    }
}
